#include "Szachownica.h"
#include <iostream>

#pragma warning (disable: 4996)// stare funkcje czasu, na czasie poszukam nowszych ciekawszych, nie blokowac wyswietlania innych warningow

using std::cout;
using std::endl;

#define WYMIAR_X 8
#define WYMIAR_Y 8

Szachownica::Szachownica()
{
	bool bialykolor = true; //niszczone po zakonczeniu pracy konstruktora
		cout << "Zaczynam konstrukcje szachownicy" << endl;
//******************************ALOKACJA SZACHOWNICY**************************************
   for(register size_t i = 0; i < WYMIAR_X ; i++) //register //wymiar X
   {
	  
	      for(register size_t j = 0; j < WYMIAR_Y; j++) // wymiar Y
		  {
//***********************************USTALANIE KOLORU*************************************
			  bialykolor = !bialykolor; //Naprawde nie ma potrzeby tutaj nic dzielic tylko po to zeby ustalic jakie bedzie mialo tlo, wystarczy takie cudo
//*****************************************************************************************
				  { //dodatkowe klamry pozwalaja na usuniecie obiektu jakiespole, przed kazdym nastepnym przebiegiem petli
					  //nie ma koniecznosci uzywania destruktora na sile

						pole jakiespole(i,j,bialykolor);
		         		wiersz.push_back(jakiespole);

				  }				  
		  }
		  bialykolor = !bialykolor;
	      szachownica.push_back(wiersz);
	      wiersz.clear();
   }

//*****************************************************************************************
   

   zapis_log_graczy.open("log_graczy.log", std::ios::app);
   zapis_log_aplikacji.open("log_aplikacji.log", std::ios::app); //log dopisujemy zawsze na koncu

   if (zapis_log_graczy.is_open() == true)
   {
	   cout << "Strumien logu graczy otwarty" << endl;
   }
   if (zapis_log_aplikacji.is_open() == true)
   {
	   cout << "Strumien logu aplikacji otwarty" << endl;
	   WyslijDoLoguAplikacji("Uruchomienie aplikacji");
   }
   cout << "Szachownica zbudowana" << endl;

}
void Szachownica::wygeneruj_stan_poczatkowy()
{
	_gra_aktywna = true; //odblokowanie mozliwosci ruchu figur na szachownicy
	//figury biale
	szachownica[0][0].UtworzFigureWedlugTypu(6,1);
	szachownica[1][0].UtworzFigureWedlugTypu(2,1);
	szachownica[2][0].UtworzFigureWedlugTypu(0,1);
	szachownica[3][0].UtworzFigureWedlugTypu(1,1);
	szachownica[4][0].UtworzFigureWedlugTypu(3,1);
	szachownica[5][0].UtworzFigureWedlugTypu(0,1);
	szachownica[6][0].UtworzFigureWedlugTypu(2,1);
	szachownica[7][0].UtworzFigureWedlugTypu(6,1);
	for (register size_t i = 0; i < 8; i++)
	{
		szachownica[i][1].UtworzFigureWedlugTypu(4,1);
	}


	//figury czarne
	szachownica[0][7].UtworzFigureWedlugTypu(6,0);
	szachownica[1][7].UtworzFigureWedlugTypu(2,0);
	szachownica[2][7].UtworzFigureWedlugTypu(0,0);
	szachownica[3][7].UtworzFigureWedlugTypu(1,0);
	szachownica[4][7].UtworzFigureWedlugTypu(3,0);
	szachownica[5][7].UtworzFigureWedlugTypu(0,0);
	szachownica[6][7].UtworzFigureWedlugTypu(2,0);
	szachownica[7][7].UtworzFigureWedlugTypu(6,0);
	for (register size_t i = 0; i < 8; i++)
	{
		szachownica[i][6].UtworzFigureWedlugTypu(4,0);
	}
	for (register size_t x = 0; x < 8; x++)
	{
		for (register size_t y = 2; y < 6; y++)
		{
			szachownica[x][y].UstawPolePuste();
		}
	}

	   _aktywny_bialy_gracz = true; //biale na starcie zaczynaja
	   Kontener_Zbite_Czarne.clear();
	   Kontener_Zbite_Biale.clear();
} 

bool Szachownica::RuchGoniec(const size_t _posX , const size_t _posY , const size_t posX, const size_t posY)
{
	if ( posX > 7 || posY > 7 ) return 0; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return 0; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)
	
	if ( posX > _posX && posY > _posY ) 
	{
		if (( posX - _posX ) == ( posY - _posY )) return 1;		//udalo sie wykonac ruch
		else return 0;             //nie udalo sie wykonac ruchu
	}
	else if ( posX < _posX && posY < _posY )
	{
		if (( _posX - posX ) == ( _posY - posY )) return 1;		//udalo sie wykonac ruch
		else return 0;             //nie udalo sie wykonac ruchu
	}
	else if ( posX > _posX && posY < _posY )
	{
		if (( posX - _posX ) == ( _posY - posY )) return 1;		//udalo sie wykonac ruch
		else return 0;              //nie udalo sie wykonac ruchu
	}
	else if ( posX < _posX && posY > _posY )
	{
		if (( _posX - posX ) == ( posY - _posY )) return 1;		//udalo sie wykonac ruch
		else return 0;                //nie udalo sie wykonac ruchu
	}
	else return 0;  //przypadek ze zmeinilismy jedno os a drugiej nie. Ruch gonca = zawsze zmiana dwoch osi polozenia
}
bool Szachownica::RuchHetman(const size_t _posX , const size_t _posY , const size_t posX, const size_t posY)
{
	if ( posX > 7 || posY > 7 ) return 0; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return 0; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)
	
	if ( posY != _posY && posX != _posX )  //jesli pozycja osi X i osi Y zmienila sie traktuje jak gonca
	{
		if ( posX > _posX && posY > _posY ) 
		{
			if (( posX - _posX ) == ( posY - _posY )) return 1;		//udalo sie wykonac ruch
			else return 0;             //nie udalo sie wykonac ruchu
		}
		else if ( posX < _posX && posY < _posY )
		{
			if (( _posX - posX ) == ( _posY - posY )) return 1;		//udalo sie wykonac ruch
			else return 0;             //nie udalo sie wykonac ruchu
		}
		else if ( posX > _posX && posY < _posY )
		{
			if (( posX - _posX ) == ( _posY - posY )) return 1;		//udalo sie wykonac ruch
			else return 0;              //nie udalo sie wykonac ruchu
		}
		else if ( posX < _posX && posY > _posY )
		{
			if (( _posX - posX ) == ( posY - _posY )) return 1;		//udalo sie wykonac ruch
			else return 0;                //nie udalo sie wykonac ruchu
		}
	}
	else        //inny przypadek traktuje jak wieze
	{
		if ( posY != _posY )
		{
			if ( posX == _posX ) return 1;		//udalo sie wykonac ruch
			else return 0;        //nie udalo sie wykonac ruchu
		}
		else 
		{
			if ( posX != _posX ) return 1;          //udalo sie wykonac ruch
			else return 0;           //nie udalo sie wykonac ruchu
		}
	}
	return 0;
}
bool Szachownica::RuchKon(const size_t _posX , const size_t _posY , const size_t posX, const size_t posY)
{
	if ( posX > 7 || posY > 7 ) return 0; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return 0; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)
	
	if ( posX == _posX+2 )
	{
		if ( posY == _posY+1 || posY == _posY-1 ) return 1;		//udalo sie wykonac ruch
		else return 0;        //nie udalo sie wykonac ruchu
	}
	else if ( posX == _posX-2 )
	{
		if ( posY == _posY+1 || posY == _posY-1 ) return 1;		//udalo sie wykonac ruch
		else return 0;       //nie udalo sie wykonac ruchu
	}
	else if ( posY == _posY+2 )
	{
		if ( posX == _posX+1 || posX == _posX-1 ) return 1;		//udalo sie wykonac ruch
		else return 0;          //nie udalo sie wykonac ruchu
	}
	else if ( posY == _posY-2 )
	{
		if ( posX == _posX+1 || posX == _posX-1 ) return 1;		//udalo sie wykonac ruch
		else return 0;            //nie udalo sie wykonac ruchu
	}
	else return 0;	           //nie udalo sie wykonac ruchu
}
bool Szachownica::RuchKrol(const int _posX , const int _posY , const int posX, const int posY)
{
	if ( posX > 7 || posY > 7 ) return false; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return false; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)

	if ( posX > _posX+1 || posX < _posX-1 ) return false;            //sprawdzanie krol moze tylko o jedno pole sie poruszac
	if ( posY > _posY+1 || posY < _posY-1 ) return false;      //sprawdzanie krol moze tylko o jedno pole sie poruszac
	return true;           //udalo sie wykonac ruch          //udalo sie wykonac ruch
}
bool Szachownica::RuchWieza(const size_t _posX , const size_t _posY , const size_t posX, const size_t posY)
{
	if ( posX > 7 || posY > 7 ) return 0; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return 0; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)
	
	if ( posY != _posY )
	{
		if ( posX == _posX ) return 1;		//udalo sie wykonac ruch
		else return 0;        //nie udalo sie wykonac ruchu
	}
	else 
	{
		if ( posX != _posX ) return 1;          //udalo sie wykonac ruch
		else return 0;           //nie udalo sie wykonac ruchu
	}
}
bool Szachownica::RuchPionek(const size_t _posX , const size_t _posY , const size_t posX, const size_t posY, const bool kolor, const size_t TypFigury )
{
	if ( posX > 7 || posY > 7 ) return 0; //czy przekroczylismy zakres tablicy podajac miejsce do ktorego sie ruszamy
	if ( posX == _posX && posY == _posY ) return 0; //czy wogule wykonujemy jakis ruch (czy pozycja sie zmieni)
	
	
	//===================================================================== czy operujemy bialymi pionkami jesli tak to jedziemy w gore
	if ( kolor == true )    
	{
		if ( posX == _posX )    //dla podstawowego ruchu pionowo
		{
			if ( TypFigury == 4 )         //czy pionek rusza sie poraz pierwszy
			{	
				if ( posY < _posY+3 && posY > _posY ) return 1;       //wykonalismy ruch
				else return 0;  //nie udalo sie wykonac ruchu, niezgodnie z zasadami osi Y
			}
			else 			// pionek rusza sie po raz n-ty n>1
			{
				if ( posY < _posY+2 && posY > _posY ) return 1;       //wykonalismy ruch
				else return 0;  //nie udalo sie wykonac ruchu, niezgodnie z zasadami osi Y
			}
		}
		else if (( posX == _posX+1 || posX == _posX-1 ) && (posY < _posY+2 && posY > _posY)) return 1;
		else return 0;
	}
	//=======================================================================jednak operujemy czarnymi i jedziemy w dol
	else     
	{
		if ( posX == _posX )    //dla podstawowego ruchu pionowo
		{
			if ( TypFigury == 4 )         //czy pionek rusza sie poraz pierwszy
			{	
				if ( posY > _posY-3 && posY < _posY ) return 1;       //wykonalismy ruch
				else return 0;  //nie udalo sie wykonac ruchu, niezgodnie z zasadami osi Y
			}
			else 			// pionek rusza sie po raz n-ty n>1
			{
				if ( posY > _posY-2 && posY < _posY ) return 1;       //wykonalismy ruch
				else return 0;  //nie udalo sie wykonac ruchu, niezgodnie z zasadami osi Y
			}
		}
		else if (( posX == _posX+1 || posX == _posX-1 ) && (posY > _posY-2 && posY < _posY)) return 1; //dla ruchu ktory wymusza uzycie bicia
		else return 0;
	}

}

bool Szachownica::SprawdzWieza (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor)//dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	size_t ix = _posX;    // dla przypomnienia _posX i _posY to polozenie aktualne figury, gracz podaje te bez "_"
	size_t iy = _posY;    //poniewaz wartosci ktore sa const nie moge wsadzic do petli korzystam z ix i iy
	
	//============================================================jedziemy po wierszach bo X sie nie zmienia
	if ( posX == _posX ) // sprawdzenie czy bedziemy jechac po wierszach czy kolumnach
	{
		if ( iy < posY )        //tu sprawdzam czy dazymy do gory czy do dolu
		{
			while (iy < posY)    //dazymy z nasza pozycja iy do podanej przez gracza posY
			{
				++iy;
				if ( szachownica[posX][iy].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
				{
					if ( iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
		}
		else      //(przypadek odwrotny do ( iy < posY )
		{
			while (iy > posY)    //dazymy z nasza pozycja iy do podanej przez gracza posY
			{
				--iy;
				if ( szachownica[posX][iy].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
				{
					if ( iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
		}
	}
	
	//============================================================jedziemy po kolumnach bo Y sie nie zmienia
	if ( posY == _posY )
	{
		if ( ix < posX )        //tu sprawdzam czy dazymy do gory czy do dolu
		{
			while (ix < posX)    //dazymy z nasza pozycja iy do podanej przez gracza posY
			{
				++ix;
				if ( szachownica[ix][posY].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
				{
					if ( ix == posX && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
		}
		else      //(przypadek odwrotny do ( ix < posX )
		{
			while (ix > posX)   //dazymy z nasza pozycja iy do podanej przez gracza posY
			{
				--ix;
				if ( szachownica[ix][posY].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
				{
					if ( ix == posX && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
		}
	}
	cout << "\nNie nastapil zaden warunek";   //takie male zabezpieczenie do testowania. Wyswietlenie tego komunikatu oznacza cos nie tak z warunkami tej metody
	return 0;
}
bool Szachownica::SprawdzKon (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor) //dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	if ( szachownica[posX][posY].czy_wolne() == false )
	{
		if ( szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
		else return 0;
	}
	return 1;
}
bool Szachownica::SprawdzKrol (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor) //dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	if ( szachownica[posX][posY].czy_wolne() == false )
	{
		if ( szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
		else return 0;
	}
	return 1;
}
bool Szachownica::SprawdzGoniec (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor) //dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	size_t ix = _posX;    // dla przypomnienia _posX i _posY to polozenie aktualne figury, gracz podaje te bez "_"
	size_t iy = _posY;    //poniewaz wartosci ktore sa const nie moge wsadzic do petli korzystam z ix i iy
	
	if ( posX > _posX && posY > _posY )
	{
		while ( ix < posX && iy < posY  )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
		{
			++ix;
			++iy;
			if ( szachownica[ix][iy].czy_wolne() == false )
			{
				if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
				else return 0;
			}
		}
		return 1;
	}
	else if ( posX < _posX && posY < _posY )
	{
		while ( ix > posX && iy > posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
		{
			--ix;
			--iy;
			if ( szachownica[ix][iy].czy_wolne() == false )
			{
				if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
				else return 0;
			}
		}
		return 1;
	}
	else if ( posX > _posX && posY < _posY )
	{
		while ( ix < posX && iy > posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
		{
			++ix;
			--iy;
			if ( szachownica[ix][iy].czy_wolne() == false )
			{
				if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
				else return 0;
			}
		}
		return 1;
	}
	else if ( posX < _posX && posY > _posY )
	{
		while ( ix > posX && iy < posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
		{
			--ix;
			++iy;
			if ( szachownica[ix][iy].czy_wolne() == false )
			{
				if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
				else return 0;
			}
		}
		return 1;
	}
	cout << "\nNie nastapil zaden warunek";   //takie male zabezpieczenie do testowania. Wyswietlenie tego komunikatu oznacza cos nie tak z warunkami tej metody
	return 0;
}
bool Szachownica::SprawdzHetman (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor) //dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	size_t ix = _posX;    // dla przypomnienia _posX i _posY to polozenie aktualne figury, gracz podaje te bez "_"
	size_t iy = _posY;    //poniewaz wartosci ktore sa const nie moge wsadzic do petli korzystam z ix i iy

	if ( posY != _posY && posX != _posX )  //jesli pozycja osi X i osi Y zmienila sie traktuje jak gonca
	//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Traktowanie jak goniec
	{
		if ( posX > _posX && posY > _posY )
		{
			while ( ix < posX && iy < posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
			{
				++ix;
				++iy;
				if ( szachownica[ix][iy].czy_wolne() == false )
				{
					if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;
		}
		else if ( posX < _posX && posY < _posY )
		{
			while ( ix > posX && iy > posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
			{
				--ix;
				--iy;
				if ( szachownica[ix][iy].czy_wolne() == false )
				{
					if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;
		}
		else if ( posX > _posX && posY < _posY )
		{
			while ( ix < posX && iy > posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
			{
				++ix;
				--iy;
				if ( szachownica[ix][iy].czy_wolne() == false )
				{
					if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;
		}
		else if ( posX < _posX && posY > _posY )
		{
			while ( ix > posX && iy < posY )   // w zasadzie nie trzeba az dwoch warunkow bo jesli metoda Ruch gonca uzna ze sa to ruchy zgodne z zasadami to tu powinny oba dojsc do zadanej wartosci w tym samym czasie
			{
				--ix;
				++iy;
				if ( szachownica[ix][iy].czy_wolne() == false )
				{
					if ( ix == posX && iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;   //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
					else return 0;
				}
			}
			return 1;
		}
	}
	else        //inny przypadek traktuje jak wieze
	//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Traktowanie jak wieza
	{
		if ( posX == _posX ) // sprawdzenie czy bedziemy jechac po wierszach czy kolumnach
		{
			if ( iy < posY )        //tu sprawdzam czy dazymy do gory czy do dolu
			{
				while ( iy < posY )    //dazymy z nasza pozycja iy do podanej przez gracza posY
				{
					++iy;
					if ( szachownica[posX][iy].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
					{
						if ( iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
						else return 0;
					}
				}
				return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
			}
			else if ( iy > posY )      //(przypadek odwrotny do ( iy < posY )
			{
				while ( iy > posY )    //dazymy z nasza pozycja iy do podanej przez gracza posY
				{
					--iy;
					if ( szachownica[posX][iy].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
					{
						if ( iy == posY && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
						else return 0;
					}
				}
				return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
			}
		}
	
		//============================================================jedziemy po kolumnach bo Y sie nie zmienia
		if ( posY == _posY )
		{
			if ( ix < posX )        //tu sprawdzam czy dazymy do gory czy do dolu
			{
				while ( ix < posX )    //dazymy z nasza pozycja iy do podanej przez gracza posY
				{
					++ix;
					if ( szachownica[ix][posY].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
					{
						if ( ix == posX && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
						else return 0;
					}
				}
				return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
			}
			else if ( ix > posX )     //(przypadek odwrotny do ( ix < posX )
			{
				while ( ix > posX )    //dazymy z nasza pozycja iy do podanej przez gracza posY
				{
					--ix;
					if ( szachownica[ix][posY].czy_wolne() == false )  //wewnatrz petli sprawdzamy pokolei czy pola na naszej drodze sa puste
					{
						if ( ix == posX && szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
						else return 0;
					}
				}
				return 1;  //petla przeszla i nie zakonczyla na returnie tzn ze nie ma nic na drodze, ruch mozliwy
			}
		}
	}
	cout << "\nNie nastapil zaden warunek";   //takie male zabezpieczenie do testowania. Wyswietlenie tego komunikatu oznacza cos nie tak z warunkami tej metody
	return 0;
}
bool Szachownica::SprawdzPionek (const size_t _posX, const size_t _posY, const size_t posX, const size_t posY, const bool kolor, const size_t TypFigury) //dla przypomnienia: _posX i _posY to pozycje poczatkowe figury a posX i posY to koncowe
{
	size_t iy = _posY;
	size_t ix = _posX;

	if ( posX == _posX )
	{
		if ( posY - _posY == 1 ||  posY - _posY == -1 ) //sprawdzanie czy pionek sie porusza o jedno pole
		{
			if ( szachownica[posX][posY].czy_wolne() == false ) return 0;
			else return 1;
		}
		else if ( posY - _posY == 2 ||  posY - _posY == -2 )
		{
			if ( iy < posY )
			{
				while ( iy < posY ) 
				{
					++iy;
					if ( szachownica[posX][iy].czy_wolne() == false ) return 0;
				}
				return 1;
			}
			else if ( iy > posY )
			{
				while ( iy > posY ) 
				{
					--iy;
					if ( szachownica[posX][iy].czy_wolne() == false ) return 0;
				}
				return 1;
			}
		}
	}
	else   //jedziemy na ukos, czy bedzie bicie?
	{
		if ( szachownica[posX][posY].czy_wolne() == false )
		{
			if ( szachownica[posX][posY].czy_bialy() != kolor ) return 1;  //TU NIEMA BYC TYLKO RETURN ALE TRZEBA DODAC BICIE
			else return 0;
		}
		else return 0; //tu jest 0 bo jesli na ukosie nie ma figury przeciwnika to pinoek nie moze tam jechac
	}
	cout << "\nNie nastapil zaden warunek";   //takie male zabezpieczenie do testowania. Wyswietlenie tego komunikatu oznacza cos nie tak z warunkami tej metody
	return 0;
}

const size_t Szachownica::WyrzucFigure(const int i, const int j) const
{
	return szachownica[i][j].ZwrocTypFigury();
}
const bool Szachownica::WyrzucKolor(const int i, const int j) const
{
	return szachownica[i][j].ZwrocKolorFigury();
}
const pole Szachownica::WyrzucStan(const int i, const int j) const
{
	return szachownica[i][j];
}

void Szachownica::ZapiszGre()
{
	std::ofstream plik; //nie widze powodu dawac tutaj fstream
	plik.open("zapis.txt", std::ios::trunc); //trzeba jakas ladna nazwe wymyslec i opakowac w .dat zeby "pr0fesjonalniej" wygladalo, narazie ze wzgledu na latwosc odczytu sobie to podarowalem, jak starczy czasu dorobi sie zapis/odczyt do pliku binarnie
	for (register size_t x = 0; x < 8; x++)
	{
		for (register size_t y = 0; y < 8; y++)
		{
			/*
***************************************PROTOKOL*******************************************************
				Goniec 0
				Hetman 1
				Kon 2
				Krol 3
				Pionek (przed pierwszym ruchem) 4
				Pionek (po pierwszym ruchu) 5
				Wieza 6
				Pole puste 7
				Zapisujemy na przemian typ figury a pozniej jej kolor (jesli pole jest puste, kolor to 0)
				moze kiedys mi sie zechce dorobic ladnego ifa zeby to sie bardziej elegancko zapisywalo :)
				Plik zaraz po ustawieniu warunkow poczatkowych wyglada tak:
				6 1 4 1 7 0 7 0 7 0 7 0 4 0 6 0 2 1 4 1 7 0 7 0 7 0 7 0 4 0 2 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 1 1 4 1 7 0 7 0 7 0 7 0 4 0 1 0 3 1 4 1 7 0 7 0 7 0 7 0 4 0 3 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 2 1 4 1 7 0
				Zapis leci: najpierw wartosci x a potem odpowiadajace mu y
				Ogolnie 64 iteracje, po 8 dla kazdego x
				Nastepnie zapisujemy ilosc zbitych czarnych figur, potem wczytujemy liczby i na podstawie tej informacji generujemy zbite czarne figury
				Nie ma sensu zapisywac tutaj informacji o kolorze.
				Przeskok do nastepnej linii i robimy to samo z bialymi...
				Calosc wyglada tak:
				6 1 4 1 7 0 7 0 7 0 7 0 4 0 6 0 2 1 4 1 7 0 7 0 7 0 7 0 4 0 2 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 1 1 4 1 7 0 7 0 7 0 7 0 4 0 1 0 3 1 4 1 7 0 7 0 7 0 7 0 4 0 3 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 2 1 4 1 7 0
				1 2  //czarne
				1 6  //biale

*******************************************************************************************************
			*/
			plik << szachownica[x][y].ZwrocTypFigury() << " ";
			plik << szachownica[x][y].ZwrocKolorFigury() << " " ;
		}
	}
	plik << endl;

	plik << Kontener_Zbite_Czarne.size() << " ";
	if(Kontener_Zbite_Czarne.empty() == false) //sprawdzam czy caly ten wynalazek ma sens
	{
		cout << "Istnieja zbite czarne figury" << endl;

		for (register size_t i = 0; i < Kontener_Zbite_Czarne.size(); i++)
		{
			plik << Kontener_Zbite_Czarne[i]->ZwrocTypFigury() << " ";
		}
	}
	else
	{
		cout << "Brak zbitych czarnych figur" << endl;
	}
	plik << endl; //dla zachowania zgodnosci

	plik << Kontener_Zbite_Biale.size()<< " ";
	if(Kontener_Zbite_Biale.empty() == false)
	{
		cout << "Istnieja zbite biale figury" << endl;

		for (register size_t i = 0; i < Kontener_Zbite_Biale.size(); i++)
		{
			plik << Kontener_Zbite_Biale[i]->ZwrocTypFigury() << " ";
		}
	}
	else
	{
		cout << "Brak zbitych bialych figur" << endl;
	}
	plik << endl;

	plik << _aktywny_bialy_gracz << " " << _gra_aktywna; //ostatnia informacja ktory gracz aktualnie wykonuje ruch, oraz czy gra zostala zakonczona

	plik.close();
	WyslijDoLoguAplikacji("Gra zapisana");
}
void Szachownica::UtworzFigureWedlugTypu(const size_t x, const size_t y, const size_t typ, const bool kolor)
{
	try
	{
		szachownica[x][y].UtworzFigureWedlugTypu(typ, kolor);

	}catch(bad_alloc &memoryAllocationException) //new rzuca ten wyjatek
	{
		std::cerr << "Wystapil wyjatek: " << memoryAllocationException.what() << std::endl;
		WyslijDoLoguAplikacji(memoryAllocationException.what() );
		std::abort();
		// i tak nie wiem jak to odkrecic gdy padnie taki wyjatek :)
		// wymuszam wiec smierc procesu
	}
	catch(std::exception &BladAlokacjiFigury) //a to wyjatek mojej produkcji
	{
		std::cerr << "Wystapil wyjatek: " << BladAlokacjiFigury.what() << std::endl;
		WyslijDoLoguAplikacji(BladAlokacjiFigury.what() );
		std::abort();
	}

}
void Szachownica::UtworzFigureWedlugTypuIUmiescWKontenerzeNaZbite(const size_t typ, const bool kolor)//biale 1, czarne 0
{
	try
	{
		if (kolor)
		{
			switch (typ)
			{
			case 0:
				{
					Kontener_Zbite_Biale.push_back(new Goniec(1));				
					break;
				}
			case 1:
				{
					Kontener_Zbite_Biale.push_back(new Hetman(1));
					break;
				}
			case 2:
				{
					Kontener_Zbite_Biale.push_back(new Kon(1));
					break;
				}
			case 3:
				{
					Kontener_Zbite_Biale.push_back(new Krol(1));
					break;
				}
			case 4:
				{
					Kontener_Zbite_Biale.push_back(new Pionek(1,1));
					break;
				}
			case 5:
				{
					Kontener_Zbite_Biale.push_back(new Pionek(0,1));
					break;
				}
			case 6:
				{
					Kontener_Zbite_Biale.push_back(new Wieza(1));
					break;
				}
			default:
				{
					throw BladAlokacjiFigury();
					break;
				}
			}
		}
		else
		{
			switch (typ)
			{
			case 0:
				{
					Kontener_Zbite_Czarne.push_back(new Goniec(0));				
					break;
				}
			case 1:
				{
					Kontener_Zbite_Czarne.push_back(new Hetman(0));
					break;
				}
			case 2:
				{
					Kontener_Zbite_Czarne.push_back(new Kon(0));
					break;
				}
			case 3:
				{
					Kontener_Zbite_Czarne.push_back(new Krol(0));
					break;
				}
			case 4:
				{
					Kontener_Zbite_Czarne.push_back(new Pionek(1,0));
					break;
				}
			case 5:
				{
					Kontener_Zbite_Czarne.push_back(new Pionek(0,0));
					break;
				}
			case 6:
				{
					Kontener_Zbite_Czarne.push_back(new Wieza(0));
					break;
				}
			case 7:
				{
					break;
				}
			default:
				{
					throw BladAlokacjiFigury();
					break;
				}
			}
		}
	}catch(bad_alloc &memoryAllocationException) //new rzuca ten wyjatek
	{
		std::cerr << "Wystapil wyjatek: " << memoryAllocationException.what() << std::endl;
		WyslijDoLoguAplikacji(memoryAllocationException.what() );
		std::abort();
		// i tak nie wiem jak to odkrecic gdy padnie taki wyjatek :)
		// wymuszam wiec smierc procesu
	}
	catch(std::exception &BladAlokacjiFigury)
	{
		std::cerr << "Wystapil wyjatek: " << BladAlokacjiFigury.what() << std::endl;
		WyslijDoLoguAplikacji(BladAlokacjiFigury.what() );
		std::abort();
	}
}

void Szachownica::WczytajGre() 
{
	Kontener_Zbite_Czarne.clear();
	Kontener_Zbite_Biale.clear();

	size_t tmp_typ_figury = 0;
	size_t tmp_kolor_int = 0;
	bool tmp_kolor = true;
	std::ifstream plik;
	plik.open("zapis.txt"); //trzeba jakas ladna nazwe wymyslec i opakowac w .dat zeby "pr0fesjonalniej" wygladalo, narazie ze wzgledu na latwosc odczytu sobie to podarowalem
	for (register size_t x = 0; x < 8; x++)
	{
		for (register size_t y = 0; y < 8; y++)
		{
			/*
***************************************PROTOKOL*******************************************************
				Goniec 0
				Hetman 1
				Kon 2
				Krol 3
				Pionek (przed pierwszym ruchem) 4
				Pionek (po pierwszym ruchu) 5
				Wieza 6
				Pole puste 7
				Zapisujemy na przemian typ figury a pozniej jej kolor (jesli pole jest puste, kolor to 0)
				moze kiedys mi sie zechce dorobic ladnego ifa zeby to sie bardziej elegancko zapisywalo :)
				Plik zaraz po ustawieniu warunkow poczatkowych wyglada tak:
				6 1 4 1 7 0 7 0 7 0 7 0 4 0 6 0 2 1 4 1 7 0 7 0 7 0 7 0 4 0 2 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 1 1 4 1 7 0 7 0 7 0 7 0 4 0 1 0 3 1 4 1 7 0 7 0 7 0 7 0 4 0 3 0 0 1 4 1 7 0 7 0 7 0 7 0 4 0 0 0 2 1 4 1 7 0 7 0 7 0 7 0 4 0 2 0 6 1 4 1 7 0 7 0 7 0 7 0 4 0 6 0 
				Zapis leci: najpierw wartosci x a potem odpowiadajace mu y
				Ogolnie 64 iteracje, po 8 dla kazdego x

*******************************************************************************************************
			*/
			plik >> tmp_typ_figury;
			plik >> tmp_kolor;
			UtworzFigureWedlugTypu(x, y, tmp_typ_figury, tmp_kolor);
		}
	}

	size_t ilosc_danych_do_wczytania = 0; //wniosek? zawsze zeruj zmienne na poczatek
	plik >> ilosc_danych_do_wczytania;
	if (ilosc_danych_do_wczytania > 0)
	{
		for(register size_t i = 0; i < ilosc_danych_do_wczytania;i++) 
		{
			plik >> tmp_typ_figury;
			UtworzFigureWedlugTypuIUmiescWKontenerzeNaZbite(tmp_typ_figury, 0); //1 biale, 0 czarne
		}
	}

	ilosc_danych_do_wczytania = 0;
	plik >> ilosc_danych_do_wczytania;
	if (ilosc_danych_do_wczytania > 0)
	{
		for(register size_t i = 0; i < ilosc_danych_do_wczytania; i++)
		{
			plik >> tmp_typ_figury;
			UtworzFigureWedlugTypuIUmiescWKontenerzeNaZbite(tmp_typ_figury, 1); //1 biale, 0 czarne
		}
	}
	plik >> _aktywny_bialy_gracz; //wczytanie ktory gracz jest przy ruchu
	plik >> _gra_aktywna; //wczytywanie czy gra sie zakonczyla

	plik.close();
	std::cout << "Plik wczytany!!!" << std::endl;
	std::cout << "Przy ruchu jest gracz ";
	if (_aktywny_bialy_gracz == true)
	{
		cout << "bialy" << endl;
	}
	else
	{
		cout << "czarny" << endl;
	}
	WyslijDoLoguAplikacji("Gra wczytana");
}

const std::string Szachownica::ZwrocNazweFigury(const Figura* NazwaFigury)
{
	std::string tymczasowy;
	tymczasowy = typeid(*NazwaFigury).name();
	tymczasowy.erase(0,6); //usuwam slowo Class i spacje, ciekawe jakby to wygladalo z uzyciem boost
	return tymczasowy;
	//mozna to bylo zrobic polimorficznie, na pewno byloby to szybsze, ale chcialem sprobowac czegos nowego
}

void Szachownica::ZbijFigure(const size_t pozycja_x, const size_t pozycja_y)
{
	if (szachownica[pozycja_x][pozycja_y].czy_wolne() == false) //zmiana warunku pozwoli na przyspieszenie dzialania if'a, procesor bedzie mnial mniej operacji do wykonania 
	{
		{
			std::string tymczasowy; //string zostanie zdealokowany 
			tymczasowy = "Figura ";
			tymczasowy += ZwrocNazweFigury(szachownica[pozycja_x][pozycja_y].ZwrocWskNaFigure() );
			tymczasowy += " na pozycji: ";
			tymczasowy += szachownica[pozycja_x][pozycja_y].daj_wspX();
			tymczasowy += szachownica[pozycja_x][pozycja_y].daj_wspY();
			tymczasowy += " zostala wlasnie zbita";

			WyslijDoLoguGracza(tymczasowy);
			cout << tymczasowy << endl;
		}
		if (szachownica[pozycja_x][pozycja_y].ZwrocTypFigury() == 3)
		{
			std::string tymczasowy = "Wygral gracz ";
			if (szachownica[pozycja_x][pozycja_y].ZwrocKolorFigury())
			{
				tymczasowy += "czarny!!!";
			}
			else
			{
				tymczasowy += "bialy!!!";
			}
			WyslijDoLoguGracza(tymczasowy);
			cout << tymczasowy << endl;
			_gra_aktywna = false;
			//dorobic informacje na oknie SDL
		}

		if (szachownica[pozycja_x][pozycja_y].ZwrocKolorFigury() == true) // 1 dla kolor bialy, 0 dla czarny, 
		{
			Kontener_Zbite_Biale.push_back(szachownica[pozycja_x][pozycja_y].ZwrocWskNaFigure() ); 
			szachownica[pozycja_x][pozycja_y].UstawPolePuste(); //teoretycznie niepotrzebne skoro za chwile i tak wskaznik zostanie uzupelniony przez zbijajaca figure, zostawilem dla pewnosci
		}
		else
		{
			Kontener_Zbite_Czarne.push_back(szachownica[pozycja_x][pozycja_y].ZwrocWskNaFigure() );
			szachownica[pozycja_x][pozycja_y].UstawPolePuste();
		}
	}
	else
	{
		{
			std::string tymczasowy; //string zostanie zdealokowany 
			tymczasowy = "Wykryto niepoprawny ruch!!! Pole ";
			tymczasowy += " na pozycji: ";
			tymczasowy += szachownica[pozycja_x][pozycja_y].daj_wspX();
			tymczasowy += szachownica[pozycja_x][pozycja_y].daj_wspY();
			tymczasowy += " jest puste";

			WyslijDoLoguGracza(tymczasowy);
			cout << tymczasowy << endl;
		}
	}
}
void Szachownica::WyslijDoLoguAplikacji(std::string komunikat)
{
	time_t czas;
	tm *ptr;
	time ( &czas );
	ptr = localtime ( &czas );
	char* data = asctime (ptr);
	zapis_log_aplikacji << "Czas: " << data << " " << komunikat << std::endl;
}
void Szachownica::WyslijDoLoguGracza(std::string komunikat)
{
	time_t czas;
	tm *ptr;
	time ( &czas );
	ptr = localtime ( &czas );
	char* data = asctime (ptr);
	zapis_log_graczy << "Czas: " << data << " " << komunikat << std::endl;
}

void Szachownica::ZmienGracza()
{
	std::string tymczasowy = "Zmiana koloru aktywnego gracza z ";
	tymczasowy += ZwrocNazweGracza();
	tymczasowy += " na ";
	_aktywny_bialy_gracz = !_aktywny_bialy_gracz;
	tymczasowy += ZwrocNazweGracza();
	WyslijDoLoguGracza(tymczasowy);
	cout << tymczasowy << endl;
}

Szachownica::~Szachownica()
{
	zapis_log_graczy.close();
	WyslijDoLoguAplikacji("Zamkniecie aplikacji");
	zapis_log_aplikacji.close();
}

std::string Szachownica::ZwrocNazweGracza()
{
	if (_aktywny_bialy_gracz)
	{
		return "bialy ";
	}
	else
	{
		return "czarny ";
	}
}

void Szachownica::WykonajRuch(const size_t pozycja_startowa_x, const size_t pozycja_startowa_y, const size_t pozycja_koncowa_x, const size_t pozycja_koncowa_y)
{

	if (SprawdzPoprawnoscRuchu(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, _aktywny_bialy_gracz) )
	{
		if (szachownica[pozycja_koncowa_x][pozycja_koncowa_y].czy_wolne() ) //opcja kiedy ruch moze byc wykonany, czysty ruch na wolna pozycje
		{
			if(szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() == 4)
			{
				szachownica[pozycja_startowa_x][pozycja_startowa_y].UstawFaktZePionekWykonalSwojPierwszyRuch(); 
			}
			szachownica[pozycja_koncowa_x][pozycja_koncowa_y].UtworzFigureWedlugTypu(szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury(), szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocKolorFigury() ); //wiem ze jest to diabelnie nieeleganckie
			szachownica[pozycja_startowa_x][pozycja_startowa_y].ZdealokujFigure();
			szachownica[pozycja_startowa_x][pozycja_startowa_y].UstawPolePuste();
			{
					std::string tymczasowy = "Gracz ";
					tymczasowy += ZwrocNazweGracza();
					tymczasowy += " wykonal ruch z pozycji ";
					tymczasowy += szachownica[pozycja_startowa_x][pozycja_startowa_y].daj_wspX();
					tymczasowy += szachownica[pozycja_startowa_x][pozycja_startowa_y].daj_wspY();
					tymczasowy += " na pozycje ";
					tymczasowy += szachownica[pozycja_koncowa_x][pozycja_koncowa_y].daj_wspX();
					tymczasowy += szachownica[pozycja_koncowa_x][pozycja_koncowa_y].daj_wspY();

					WyslijDoLoguGracza(tymczasowy);
			}
			ZmienGracza();
		}
		else
		{
			if (_aktywny_bialy_gracz == szachownica[pozycja_koncowa_x][pozycja_koncowa_y].czy_bialy() ) //proba zbicia wlasnej figury, zastanawiam sie czy to jest potrzebne, metody odpowiedzialne za sprawdzanie sprawdzaja to?
			{
				cout << "Probujesz zbic swoja wlasna figure, cofam to zadanie" << endl;
				{
					std::string tmp = "Gracz "; //string zostanie zdealokowany
					tmp += ZwrocNazweGracza();
					tmp += "probowal zbic swoja wlasna figure!!!";
				
					WyslijDoLoguGracza(tmp);
				}
			}
			else //opcja kiedy ruch moze byc wykonany, + bicie figury przeciwnika
			{
				{
					std::string tymczasowy = "Gracz ";
					tymczasowy += ZwrocNazweGracza();
					tymczasowy += " wykonal ruch z pozycji ";
					tymczasowy += szachownica[pozycja_startowa_x][pozycja_startowa_y].daj_wspX();
					tymczasowy += szachownica[pozycja_startowa_x][pozycja_startowa_y].daj_wspY();
					tymczasowy += " na pozycje ";
					tymczasowy += szachownica[pozycja_koncowa_x][pozycja_koncowa_y].daj_wspX();
					tymczasowy += szachownica[pozycja_koncowa_x][pozycja_koncowa_y].daj_wspY();
					tymczasowy += " zbijajac ";
					tymczasowy += ZwrocNazweFigury(szachownica[pozycja_koncowa_x][pozycja_koncowa_y].ZwrocWskNaFigure() );

					WyslijDoLoguGracza(tymczasowy);
				}
				if(szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() == 4)
				{
					szachownica[pozycja_startowa_x][pozycja_startowa_y].UstawFaktZePionekWykonalSwojPierwszyRuch(); 
				}
				ZbijFigure(pozycja_koncowa_x, pozycja_koncowa_y); //sprawdzanie czy zdejmujemy krola, w metodzie
				szachownica[pozycja_koncowa_x][pozycja_koncowa_y].UtworzFigureWedlugTypu(szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury(), szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocKolorFigury() ); //wiem ze jest to diabelnie nieeleganckie
				szachownica[pozycja_startowa_x][pozycja_startowa_y].ZdealokujFigure();
				szachownica[pozycja_startowa_x][pozycja_startowa_y].UstawPolePuste();
				szachownica[pozycja_koncowa_x][pozycja_koncowa_y].UstawPoleZajete();
				ZmienGracza();
			}
		}
	}
	else //ruch jest calkowicie niepoprawny
	{
		cout << "Ruch jest niezgodny z zasadami!!!" << endl;
	}
}

const bool Szachownica::SprawdzPoprawnoscRuchu(const size_t pozycja_startowa_x, const size_t pozycja_startowa_y, const size_t pozycja_koncowa_x, const size_t pozycja_koncowa_y, const bool kolor)
{
	if(szachownica[pozycja_startowa_x][pozycja_startowa_y].czy_wolne() == false)
	{ //pole jest zajete, rozpatrujemy przypadki
		if(szachownica[pozycja_startowa_x][pozycja_startowa_y].czy_bialy() == _aktywny_bialy_gracz) //sprawdzamy czy figura na polu startowym moze byc ruszona przez obecnego gracza
		{
			switch(szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() ) //zakladam ze metody odpowiedzialne za sprawdzanie sa poprawne i zwracaja jedynke jesli ruch jest poprawny a 0 jesli nie
			{
			case 0:
				{
					if ( RuchGoniec(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y ) == 1 &&
						SprawdzGoniec(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor ) == 1 && _gra_aktywna)return 1;
					else return 0;
					break;
				}
			case 1:
				{
					if ( RuchHetman(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y ) == 1 &&
						SprawdzHetman(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor ) == 1 && _gra_aktywna )return 1;
					else return 0;
					break;
				}
			case 2:
				{
					if ( RuchKon(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y ) == 1 &&
						SprawdzKon(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor ) == 1 && _gra_aktywna )return 1;
					else return 0;
					break;
				}
			case 3:
				{ 
					if ( RuchKrol(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y ) == 1 &&
						SprawdzKrol(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor ) == 1 && _gra_aktywna )return 1;
					else return 0;
					break;
				}
			case 4:
				{
					if ( RuchPionek(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor , szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() ) == 1 &&
						SprawdzPionek(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor , szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() ) == 1 && _gra_aktywna )return 1;
					else return 0;
					break;
				}
			case 5:
				{
					if ( RuchPionek(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor , szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() ) == 1 &&
						SprawdzPionek(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor , szachownica[pozycja_startowa_x][pozycja_startowa_y].ZwrocTypFigury() ) == 1 && _gra_aktywna )return 1;
					else return 0;
				}
			case 6:
				{
					if ( RuchWieza(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y ) == 1 &&
						SprawdzWieza(pozycja_startowa_x, pozycja_startowa_y, pozycja_koncowa_x, pozycja_koncowa_y, kolor ) == 1 && _gra_aktywna )return 1;
					else return 0;
					break;
				}
			default:
				{
					cout << "Sytuacja nie powinna miec miejsca" << endl;
					return false;
					break;
				}
			}

		}
		else
		{ //nie mozemy ruszyc tej figury, nie nalezy ona do nas
			return false; 
		}

	}
	else //pole jest puste
	{
		return false;
	}
}

const size_t Szachownica::ZwrocIloscElementowWKontenerzeNaZbiteFigury(const bool bialy_kolor) const
{
	if (bialy_kolor)
	{
		return Kontener_Zbite_Biale.size();
	}
	else
	{
		return Kontener_Zbite_Czarne.size();
	}
}

const size_t Szachownica::ZwrocTypFiguryZnajdujacejSieWKontenerzeNaZbiteFigury(const bool bialy_kolor, const size_t pozycja) const
{
	if (bialy_kolor)
	{
		return Kontener_Zbite_Biale[pozycja]->ZwrocTypFigury();
	}
	else
	{
		return Kontener_Zbite_Czarne[pozycja]->ZwrocTypFigury();
	}
}

const bool Szachownica::ZwrocKolorFiguryZnajdujacejSieWKontenerzeNaZbiteFigury(const bool bialy_kolor, const size_t pozycja) const
{
	if (bialy_kolor)
	{
		return Kontener_Zbite_Biale[pozycja]->czy_bialy();
	}
	else
	{
		return Kontener_Zbite_Czarne[pozycja]->czy_bialy();
	}
}

const bool Szachownica::SprawdzCzyGraZakonczona() const
{
	return _gra_aktywna;
}